package com.justnow.offer;



import java.util.Scanner;

/**
 * @author justnow
 * Created on 2020-09-18
 * Description
 *
 *
 * 多余的连接
 * 时间限制： 3000MS
 * 内存限制： 589824KB
 * 题目描述：
 * 假设我们有一个连通的无向图，里面可能最多存在一个环，检测输入的图是否有环。
 *
 * 这个图有n个不重复的顶点，输入的图的边[a,b]，满足a<b。如果有环输出Y，否则输出N。
 *
 * n表示输入数组的长度，数组里每个数字都小于n。 (n<=10000)
 *
 * 1--2–3
 *
 *     |    |
 *
 *    5–4
 *
 * 如上图，2-3-4-5是一个环
 *
 *
 *
 * 输入描述
 * public String removeOneConnection(int[][] edges)
 *
 * 说明:
 *
 * edges表示输入的图的边
 *
 * 输出描述
 * 返回：Y or N
 *
 *
 * 样例输入
 * [[1,2],[2,3],[3,4],[4,5],[2,5]]
 * 样例输出
 * Y
 *
 * 提示
 * 样例 2：
 * 输入：
 * [[1,2],[2,3],[3,4],[4,5]]
 * 输出：
 * N
 */
public class BiLiFeng01 {
    static int[] parents;
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        str = str.replace('[', ' ');
        str = str.replace(']', ' ');
        String[] split = str.split(",");
        int length = split.length;
        int[] temp  = new int[length];
        for (int i = 0; i < length; i++) {
            temp[i] = Integer.valueOf(split[i].trim());
        }
        int[][] edge = new int[length / 2][2];
        for (int i = 0; i < length / 2; i++) {
            edge[i][0] = temp[2 * i];
            edge[i][1] = temp[2 * i + 1];
        }

        removeOneConnection(edge);

    }

    public static  void removeOneConnection(int[][] edges) {

        int n = edges.length + 1;
        initUF(n);
        for (int[] edge : edges) {
            int x = edge[0], y = edge[1];
            boolean flag = true;
            try {
                flag = union(x, y);
            } catch (Exception e) {
                System.out.println("N");
            }
            if (!flag) {
                System.out.println("Y");
                return;
            }
        }
        System.out.println("N");
    }

    public static void initUF(int n) {
        parents = new int[n];
        for (int i = 0; i < n; i++) {
            parents[i] = i;
        }
    }

    public static int find(int x) {
        if (x != parents[x]) {
            parents[x] = find(parents[x]);
        }
        return parents[x];
    }

    public static boolean union(int x, int y) {
        int rootx = find(x), rooty = find(y);
        if (rootx == rooty) return false;
        parents[rootx] = rooty;
        return true;
    }
}
